/*
 * @Author: fengxx
 * @Date: 2025-08-21 17:06:43
 * @LastEditors: fengxx
 * @LastEditTime: 2025-09-04 17:08:05
 */
// import { a } from "./test";
// console.log(a);

// import { A, a } from "./test";
// let a1 = new A();
// console.log(a1.a, a);
// let b: string | boolean = true;
// let c: 1 | 2 | 3 = 2
// enum Enum {
//   'ease-in'= 'ease-in',
// }

// type Easing = "ease-in" | "ease-out" | "ease-in-out";
// class UIElement {
//   animate(dx: number, dy: number, easing: Easing) {
//     if (easing === "ease-in") {
//     } else if (easing === "ease-out") {
//     } else if (easing === "ease-in-out") {
//     } else if (easing === "oooo") {
//       console.log(easing);
//       // error! should not pass null or undefined.
//     }
//   }
// }

// let button = new UIElement();
// button.animate(0, 0, "ease-in");
// button.animate(0, 0, "uneasy");

// type A = { name: string };
// type B = { age: number };
// type C = A & B; // C 具有 A 和 B 中的所有属性
// let person: C = { name: "John", age: 18 };

// 交叉类型有相同属性时，他们的类型有重复就取重复项，没有就是never类型
// type A = { name: string };
// type B = { name: string | number };
// type C = A & B;
// let obj: C = { name: "Alice" }; // 这是合法的
// let obj2: C = { name: 42 }; // 这是不合法的

// let someValue: any = true;
// let strLength: number = (someValue as string).length;
// console.log(strLength);
// 类型断言（两种写法：1、<类型> 2、as）

// (<any>window).abc = 123
// (window as any).abc = 123;

// interface A {
//   run: string;
// }

// interface B {
//   build: string;
//   // run: string
// }

// const fn = (type: A | B): string => {
//   return (type as A).run;
// };
//可以使⽤类型断⾔来推断他传⼊的是A接⼝的值

// const names = '⼩满'
// names = 'aa' //⽆法修改

// let names2 = '⼩满' as const
// names2 = 'aa' //⽆法修改

// const 声明的变量为引用类型时，可以更改他里面的值， as const 指定类型的变量不可以以任何方式更改（read-only）
// 数组
// let a1 = [10, 20] as const;
// const a2 = [10, 20];

// a1.unshift(30); // 错误，此时已经断⾔字⾯量为[10, 20],数据⽆法做任何修改
// a2.unshift(30); // 通过，没有修改指针

// const a = {
//   a2: 1,
// };
// let b = {
//   a1: 1,
// } as const;

// a.a2 = 2
// b.a1 = 3

// function toBoolean(something: any): boolean {
//   return something as boolean;
// }

// console.log(toBoolean(1));

// let a: string & number = '1'
// type A = { age: string };
// type B = { age: number };
// let a: A&B = {
//   age: 222
// }

// interface A {
//   readonly a: boolean;
// }
// interface C {
//   c: number;
// }
// interface B extends A {
//   b: C;
// }
// let bb: B = {
//   a: true,
//   b: {
//     c: 6,
//   },
// };

// bb.a = true

// const arr = [];
// // arr = [1]
// arr.push(1)

// function fun(i: string): any {
//   // return null
// }

// let a: string[] = ['kk']
// let a :Array<string> = ['']
// interface A {a: string};  interface A {b: number};
// let x: A;
// x={a: '', b: 1}

// abstract class A {
//   abstract fun(): void
// }

// class B extends A {
//   fun(): void {

//   }
// }

// let a = new A()

// enum Typ {
//   a,
//   b=9,
//   c,
//   d,
// }
// console.log(Typ.d);

// let a = Symbol("a");
// let obj = { [a]: 1, a: 2 };
// console.log(obj.a, obj[a]);
// let a: boolean = 9>0

// interface A {
//   a: string;
//   b: number;
// }
// class B implements A {
//   a: string = "";
//   b: number = 1;
//   c: boolean = true;
// }
// let a: A[] = [{
//   a: '',
//   b: 1
// }]
// function fun(a: number): number {
//   return a;
// }

// let fun2: (a: number) => number = function (a) {
//   return a;
// };

// function fn(a: number, b: number): number;
// function fn(a: number, b: string): string;
// function fn(a: number, b: any): any {
//   return a + b;
// }
// console.log(fn(1, 2), fn(1, "2"));

// let a = Symbol();
// let obj = { [a]: "a", b: "b" };
// console.log(Reflect.ownKeys(obj), Object.getOwnPropertySymbols(obj));

// 枚举支持反向取值（通过value拿key）
// enum Enum {
//   fall,
//   d,
//   f,
// }
// let a = Enum.f; // 2
// console.log(Enum[a]);

// class A {
//   private a: string = "a";
//   get _a(): string {
//     return this.a;
//   }
// }
// let a = new A();
// console.log(a._a);

// let a = "a";
// a = 1;

// let arr: [number, string] = [1, "a"];
// arr.push(2);
// console.log(arr);

// function fun(): void {
//   return undefined;
// }

// class A {
//   a: string;
//   constructor(a: string) {
//     this.a = a
//   }
//   static fun() {
//     console.log("ll");
//   }
// }

// class B extends A {
//   constructor() {
//     super('1')
//   }
//   static fun1() {
//     super.fun();
//   }
// }
// // let b = new B();
// B.fun1();
// type a = string
// let b:a =1

// type A = {
//   a: string;
// };
// type B = {};
// let obj: A & B;

// // 形状类
// abstract class Shape {
//   private id: number = 0;
//   constructor(id: number) {
//     this.id = id;
//   }
//   get _id(): number {
//     return this.id;
//   }
//   abstract caculateArea(): number;
// }
// // 圆形类
// class Circle extends Shape {
//   private radius: number;
//   constructor(id: number, r: number) {
//     super(id);
//     this.radius = r;
//   }
//   caculateArea(): number {
//     return Math.PI * Math.pow(this.radius, 2);
//   }
// }
// // 矩形类
// class Rectangle extends Shape {
//   private width: number;
//   private height: number;
//   constructor(id: number, w: number, h: number) {
//     super(id);
//     this.width = w;
//     this.height = h;
//   }
//   caculateArea(): number {
//     return this.width * this.height;
//   }
// }
// // 复合形状类
// class CompositeShape extends Shape {
//   shapes: Shape[] = [];
//   addShape(shape: Shape): void {
//     this.shapes.push(shape);
//   }
//   caculateArea(): number {
//     // return this.shapes.reduce((sum: number, item: Shape) => {
//     //   return sum + item.caculateArea();
//     // }, 0);
//     let sum: number = 0;
//     this.shapes.forEach((item: Shape) => {
//       sum += item.caculateArea();
//     });
//     return sum;
//   }
// }

// let circle: Shape = new Circle(1, 8);
// let rect: Shape = new Rectangle(1, 2, 3);
// let compositeShape: CompositeShape = new CompositeShape(1);
// compositeShape.addShape(circle);
// compositeShape.addShape(rect);
// console.log(compositeShape.caculateArea());

// 泛型
// function fun<T>(a: T ): T {
//   return a;
// }

// console.log(fun<string>("111"));
// console.log(fun<boolean>(true));
// let arr1: Array<string> = [];

// function Sub<T, U>(a: T, b: U): Array<T | U> {
//   const params: Array<T | U> = [a, b];
//   return params;
// }
// let arr = Sub<boolean, number>(false, 1);
// arr.push(true); // 数组相关操作也要符合反向规律

// let arr2: [string, number] = ["", 1];
// arr2.push("1");

// let foo: { <T>(arg: T): T }

// foo = function <T>(arg:T):T {
//  return arg
// }

// foo(true)
// interface Len {
//   length: number;
// }

// function getLegnth<T extends Len>(arg: T): number {
//   return arg.length; //报错 T上不存在属性“length”
// }
// getLegnth<Len>([]);

// function prop<T, K extends keyof T>(obj: T, key: K): any {
//   return obj[key];
// }

// let o = { a: 1, b: 2, c: "lll", 0: 1 }; // 'a'|'b'|'c'|0

// prop(o, "a");
// prop(o, "0"); //此时就会报错发现找不到

// class A<T> {
//   a: T;
//   b: T[] = [];
//   c: number = 0;
//   constructor(a: T) {
//     this.a = a;
//   }
//   add(a: T): T[] {
//     return [a];
//   }
// }

// let obj = new A<number>(3);
// let obj11: A<number> = new A(3);

// interface I<T> {
//   a: T;
//   b: T[];
//   c: string;
// }

// let obj1: I<number> = {
//   a: 1,
//   b: [1, 2],
//   c: "",
// };

/**
 * Partial、Pick、Readonly、Record原始封装定义
 */
// 1. keyof 将⼀个接⼝对象的全部属性取出来变成联合类型
// 2. in 我们可以理解成for in P 就是key 遍历 keyof T 就是联合类型的每⼀项
// 3. ？这个操作就是将每⼀个属性变成可选项
// 4. T[P] 索引访问操作符，与 JavaScript 种访问属性值的操作类似
// 5. keyof any 返回 string number symbol 的联合类型
// 6. extends来约束我们的类型
// 7. T 直接返回类型 做到了约束 对象的key 同时约束了 value
// type Partial1<T> = {
//   [P in keyof T]?: T[P]; // "key1"|"key2"
// };
/**
 * From T, pick a set of properties whose keys are in the union K
 */
// type Pick1<T, K extends keyof T> = {
//   [P in K]: T[P];
// };

// type Readonly1<T> = {
//   readonly [P in keyof T]: T[P];
// };

// type Record1<K extends keyof any, T> = {
//   [P in K]: T;
// };

// type Person = {
//   name: string;
//   age: number;
//   grade: number;
// };
// let p: Person = {
//   name: "1",
//   age: 1,
//   grade: 1,
// };

// Partial：将类型属性全部设置为可选属性
// type T1 = Partial<Person>;
// // Pick: 从一个类型中挑出几个属性类型出来变成一个新的类型
// type T2 = Pick<Person, "age" | "name">;
// // Readonly: 将类型属性全部设置为只读属性
// type T3 = Readonly<Person>;
// // Record：申明一些key，让他们的值的类型是第二个参数的类型
// type T4 = Record<"a" | "b", Person>;
// let t1: T1 = {
//   name: "1",
// };
// let t2: T2 = {
//   age: 1,
//   name: "sdfdsg",
// };
// let t3: T3 = {
//   name: "1",
//   age: 1,
//   grade: 1,
// };
// // t3.age = 2; // 报错，只读
// let t4: T4 = {
//   a: {
//     name: "1",
//     age: 1,
//     grade: 1,
//   },
//   b: {
//     name: "2",
//     age: 2,
//     grade: 2,
//   },
// };

// unknown:只能赋值给自身或者any; 一个unknown类型的数据可以被任何类型赋值
// let a: unknown;
// let b: any;
// let c: number;
// b = a;
// // c = a; // 报错，unknown:只能赋值给自身或者any
// // c = b; // 正确，any类型可以赋给其他类型
// a = true; // 正确，unknown类型可以赋任何值
// a = "";

// // unknown类型没有办法读取任何属性，⽅法也不可以调⽤，any是可以的
// let ay: any = { a: false, b: () => 34 };
// console.log(ay.a);
// console.log(ay.b());
// let uk: unknown = { a: false, b: () => 34 };
// console.log(uk.a); // 报错， “uk”的类型为“未知”。
// console.log(uk.b()); // 报错， “uk”的类型为“未知”。

// // 程序执⾏开始 打印 '同步输出1'
// console.log("同步输出1");
// // 定时任务是异步的，所以不会在输出'同步输出1'后输出
// setTimeout(() => {
//   console.log("异步输出");
// }, 0);
// // 以下输出都会按照程序流程同步先后打印
// console.log("同步输出2");
// console.log("同步输出3");
// console.log("同步输出4");

// // 定时器1
// setTimeout(() => {
//   console.log("异步执⾏1");
//   // 定时器2
//   setTimeout(() => {
//     console.log("异步执⾏2");
//     // 定时器3
//     setTimeout(() => {
//       console.log("异步执⾏3");
//     }, 1000);
//   }, 2000);
// }, 3000);

// function asyncFun1(callBack: any, str: string): void {
//   setTimeout(() => {
//     callBack("异步执⾏1");
//   }, 3000);
// }
// function asyncFun2(callBack: any, str: string) {
//   setTimeout(() => {
//     callBack("异步执⾏2" + str);
//   }, 2000);
// }
// function asyncFun3(callBack: any, str: string) {
//   setTimeout(() => {
//     callBack("异步执⾏3" + str);
//   }, 1000);
// }

// asyncFun1(function (res: any) {
//   console.log(res);
// }, "1");
// asyncFun2((res: any) => {
//   console.log(res);
// }, "2");
// asyncFun3((res: any) => {
//   console.log(res);
// }, "3");

// asyncFun1(function (asyncFun1Res: string) {
//   console.log(asyncFun1Res);
//   asyncFun2((asyncFun2Res: any) => {
//     console.log(asyncFun2Res);
//     asyncFun3((asyncFun3Res: any) => {
//       console.log(asyncFun3Res);
//     }, asyncFun2Res);
//   }, asyncFun1Res);
// }, "fsdf");

// 定义promise函数
// function asyncFun1(success: boolean): Promise<string> {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       if (success) {
//         resolve(`异步执⾏1`);
//       } else {
//         reject("llll");
//       }
//     }, 3000);
//   });
// }

// function asyncFun2(str?: string): Promise<string> {
//   return new Promise((resolve) => {
//     setTimeout(() => {
//       resolve(`异步执⾏2${str || ""}`);
//     }, 2000);
//   });
// }

// function asyncFun3(str?: string): Promise<string> {
//   return new Promise((resolve) => {
//     setTimeout(() => {
//       resolve(`异步执⾏3${str || ""}`);
//     }, 1000);
//   });
// }
// // 写法1
// asyncFun1(true).then((asyncFun1Res) => {
//   console.log(asyncFun1Res);
//   asyncFun2(asyncFun1Res).then((asyncFun2Res) => {
//     console.log(asyncFun2Res);
//     asyncFun3(asyncFun2Res).then((asyncFun3Res) => {
//       console.log(asyncFun3Res);
//     });
//   });
// });
// // 写法2
// asyncFun1(false)
//   .then((asyncFun1Res) => {
//     console.log(asyncFun1Res);
//     return asyncFun2(asyncFun1Res);
//   }) // .then 实现resolve函数
//   .then((asyncFun2Res) => {
//     console.log(asyncFun2Res);
//     return asyncFun3(asyncFun2Res);
//   })
//   .then((asyncFun3Res) => {
//     console.log(asyncFun3Res);
//   })
//   .catch((e) => {
//     console.log(e);
//   }); // .catch 实现reject函数

// // 写法3
// async function callAsyncFunctions() {
//   try {
//     const asyncFun1Res = await asyncFun1(true);
//     console.log(asyncFun1Res);
//     const asyncFun2Res = await asyncFun2(asyncFun1Res);
//     console.log(asyncFun2Res);
//     const asyncFun3Res = await asyncFun3(asyncFun2Res);
//     console.log(asyncFun3Res);
//   } catch (error) {
//     console.error("An error occurred:", error);
//   }
// }

// callAsyncFunctions();

// function fetchUser(): Promise<string> {
//   return new Promise((resolve) => setTimeout(() => resolve("User"), 1000));
// }
// function fetchOrders(): Promise<number[]> {
//   return new Promise((resolve, reject) =>
//     setTimeout(() => resolve([1, 2, 3]), 3000)
//   );
// }
// // Promise.all ⽤于并⾏处理多个 Promise，并在所有 Promise 都成功时返回结果数组。如果任何⼀个 Promise 失败，则整个
// // Promise.all 会⽴即失败，并返回该失败的原因（执行的时间是所有promise都执行完的时间）
// Promise.all([fetchUser(), fetchOrders()]).then(([user, orders]) => {
//   console.log(`⽤户: ${user}, 订单: ${orders}`);
// });

// // Promise.race ⽤于竞争处理多个 Promise，它会返回第⼀个被解决（resolve）或被拒绝（reject）的 Promise 的结果。⽆论其他
// // Promise 是否完成，⼀旦有⼀个 Promise 完成，Promise.race 就会⽴即返回结果。
// Promise.race([fetchUser(), fetchOrders()]).then((res) => {
//   console.log(`⽤户: ${res}, 订单: ${res}`);
// });

// // resolve返回是对象时的类型定义
// interface User {
//   id: number;
//   name: string;
// }
// function getUserById(userId: number): Promise<User> {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       resolve({ id: userId, name: "John Doe" });
//     }, 1000);
//   });
// }
// getUserById(1).then((user) => {
//   console.log(`⽤户ID: ${user.id}, ⽤户名: ${user.name}`);
// });
// interface A {
//   server: number,
//   data: string
// }

// // 模拟从服务器1获取数据
// function fetchFromServer1(): Promise<A> {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       console.log("从服务器1获取数据");
//       resolve({ server: 1, data: "Server 1 Data" });
//     }, 3000); // 模拟服务器1响应时间为3秒
//   });
// }
// // 模拟从服务器2获取数据
// function fetchFromServer2() {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       console.log("从服务器2获取数据");
//       resolve({ server: 2, data: "Server 2 Data" });
//     }, 2000); // 模拟服务器2响应时间为2秒
//   });
// }
// // 模拟从服务器3获取数据
// function fetchFromServer3() {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       console.log("从服务器3获取数据");
//       resolve({ server: 3, data: "Server 3 Data" });
//     }, 1000); // 模拟服务器3响应时间为1秒
//   });
// }

// Promise.race([fetchFromServer1(), fetchFromServer2(), fetchFromServer3() ]).then(res=>{
//   console.log(res)
// })

// Promise.all([fetchFromServer1(), fetchFromServer2(), fetchFromServer3()]).then(([r1,r2, r3])=>{

// })
// interface User {
//   userId: number;
//   verified: boolean;
// }
// function verifyUser(userId: number): Promise<User> {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       console.log(`验证⽤户 ${userId}`);
//       if (userId === 1) {
//         resolve({ userId, verified: true });
//       } else {
//         reject("⽤户验证失败");
//       }
//     }, 1000);
//   });
// }

// interface Product {
//   productId: number;
//   inStock: boolean;
// }
// function checkInventory(productId: number): Promise<Product> {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       console.log(`检查库存 产品ID: ${productId}`);
//       const inventory = 10; // 模拟库存数量
//       if (inventory > 0) {
//         resolve({ productId, inStock: true });
//       } else {
//         reject("库存不⾜");
//       }
//     }, 1000);
//   });
// }
// interface Payment {
//   userId: number;
//   amount: number;
//   paymentStatus: string;
// }
// function processPayment(userId: number, amount: number): Promise<Payment> {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       console.log(`处理⽀付 ⽤户ID: ${userId} ⽀付⾦额: $${amount}`);
//       if (amount > 0) {
//         resolve({ userId, amount, paymentStatus: "成功" });
//       } else {
//         reject("⽀付失败");
//       }
//     }, 1000);
//   });
// }

// interface Order {
//   orderId: number;
//   userId: number;
//   productId: number;
// }
// function generateOrder(userId: number, productId: number): Promise<Order> {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       console.log(`⽣成订单 ⽤户ID: ${userId} 产品ID: ${productId}`);
//       resolve({
//         orderId: Math.floor(Math.random() * 10000),
//         userId,
//         productId,
//       });
//     }, 1000);
//   });
// }

// verifyUser(1).then((res: User) => {
//   console.log(`用户${res.userId}验证${res.verified ? "成功" : "失败"}`);
//   checkInventory(1).then((res1: Product) => {
//     console.log(`商品${res1.productId}数量${res1.inStock ? "充足" : "不足"}`);
//     processPayment(res.userId, 10).then((res2: Payment) => {
//       console.log(
//         `用户${res2.userId}支付金额${res2.amount}${res2.paymentStatus}`
//       );
//       generateOrder(res.userId, res1.productId).then((res3: Order) => {
//         console.log(
//           `用户${res.userId}的商品${res1.productId}对应的订单为${res3.orderId}`
//         );
//       });
//     });
//   });
// });
// let userId: number = 1;
// let productId: number = 1;

// verifyUser(userId)
//   .then((res: User) => {
//     console.log(`用户${res.userId}验证${res.verified ? "成功" : "失败"}`);
//     return checkInventory(productId);
//   })
//   .then((res: Product) => {
//     console.log(`商品${res.productId}数量${res.inStock ? "充足" : "不足"}`);
//     return processPayment(userId, 10);
//   })
//   .then((res: Payment) => {
//     console.log(`用户${res.userId}支付金额${res.amount}${res.paymentStatus}`);
//     return generateOrder(userId, productId);
//   })
//   .then((res: Order) => {
//     console.log(`用户${userId}的商品${productId}对应的订单为${res.orderId}`);
//   });

// async function fun() {
//   let res: User = await verifyUser(1);
//   console.log(`用户${res.userId}验证${res.verified ? "成功" : "失败"}`);
//   let res1: Product = await checkInventory(1);
//   console.log(`商品${res1.productId}数量${res1.inStock ? "充足" : "不足"}`);
//   let res2: Payment = await processPayment(res.userId, 10);
//   console.log(`用户${res2.userId}支付金额${res2.amount}${res2.paymentStatus}`);
//   let res3: Order = await generateOrder(res.userId, res1.productId);
//   console.log(
//     `用户${res.userId}的商品${res1.productId}对应的订单为${res3.orderId}`
//   );
// }
// fun();

// 命名空间：缩小当前变量或者函数等等的作用域
// namespace a {
//   export const Time: number = 1000;
//   export const fn = <T>(arg: T): T => {
//     return arg;
//   };
//   fn(Time);
// }

// namespace b {
//   export const Time: number = 2000;
//   export const fn = <T>(arg: T): T => {
//     return arg;
//   };
//   fn(Time);
// }

// console.log(a.Time, b.Time, a.fn<number>(44), b.fn<string>("llll"));

// namespace a {
//   export namespace b {
//     export class Vue {
//       parameters: string;
//       constructor(parameters: string) {
//         this.parameters = parameters;
//       }
//     }
//   }
// }

// let v = a.b.Vue;

// let vv = new v("1");
// console.log(vv.parameters);

// import { V } from "./test";
// console.log(V.b);

// const test = require("./test");
// console.log(test.getTel);
// const name11 = ''

// const test = require("../test/test1");
// console.log(test.name11);
// const myModule = require("./test");
// console.log(myModule);

// as: 别名
// import { name11 as name1 } from "./test";
// import * as test from "./test";
// const { name111 } = test;
// // console.log(name);
// console.log(name1);

// $("#foo").on("click", function () {
//   console.log("dgdfgfd");
// });

// type Person = {
//   name: string;
//   age: number;
//   isEmployed: boolean;
// };

// keyof: 获取一个对象的所有key的联合
// type PersonKeys = keyof Person; //"name"|"age"|"isEmployed"

// // 封装获取对象中某个属性的函数
// function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
//   return obj[key];
// }

// let p: Person = {
//   name: "11",
//   age: 1,
//   isEmployed: true,
// };
// console.log(getProperty(p, "age"));

// type Config = {
//   apiEndpoint: string;
//   timeout: number;
// };
// function updateConfig<K extends keyof Config>(key: K, value: Config[K]) {
//   return {
//     [key]: value,
//   };
// }
// console.log(updateConfig("apiEndpoint", "https://api.example.com")); // 合法

// type APIResponse = {
//   data: object;
//   error: string;
// };
// let obj: APIResponse = {
//   data: {},
//   error: "报错",
// };

// type t = keyof APIResponse;
// type t1 = keyof typeof obj; // 先获取类型，再获取类型对应的key的联合

// type APIResponseKeys = keyof APIResponse; // "data" | "error"
// function handleResponse(key: APIResponseKeys, response: APIResponse) {
//   if (key === "error") {
//     console.error(response[key]);
//   } else {
//     console.log(response[key]);
//   }
// }

// let obj: APIResponse = {
//   data: {},
//   error: "报错",
// };
// handleResponse("data", obj);

// let person = {
//   name: "Alice",
//   age: 30,
// };
// type PersonType = typeof person;
// let anotherPerson: PersonType = {
//   name: "Bob",
//   age: 25,
// };
// let a: number = 9;
// console.log(typeof a.toFixed(2));
